.TH std::assume_aligned 3 "2024.06.10" "http://cppreference.com" "C++ Standard Libary"
.SH NAME
std::assume_aligned \- std::assume_aligned

.SH Synopsis
   Defined in header <memory>
   template< std::size_t N, class T >                    \fI(since C++20)\fP
   [[nodiscard]] constexpr T* assume_aligned( T* ptr );

   Informs the implementation that the object ptr points to is aligned to at least N.
   The implementation may use this information to generate more efficient code, but it
   might only make this assumption if the object is accessed via the return value of
   assume_aligned.

   N must be a power of 2. The behavior is undefined if ptr does not point to an object
   of type T (ignoring cv-qualification at every level), or if the object's alignment
   is not at least N.

.SH Return value

   ptr.

.SH Exceptions

   Throws nothing.

.SH Notes

   To ensure that the program benefits from the optimizations enabled by
   assume_aligned, it is important to access the object via its return value:

 void f(int* p)
 {
     int* p1 = std::assume_aligned<256>(p);
     // Use p1, not p, to ensure benefit from the alignment assumption.
     // However, the program has undefined behavior if p is not aligned
     // regardless of whether p1 is used.
 }

   It is up to the program to ensure that the alignment assumption actually holds. A
   call to assume_aligned does not cause the compiler to verify or enforce this.

      Feature-test macro     Value    Std         Feature
   __cpp_lib_assume_aligned 201811L (C++20) std::assume_aligned

.SH Example

    This section is incomplete
    Reason: no example

.SH See also

   alignof operator\fI(C++11)\fP       queries alignment requirements of a type
   alignas specifier\fI(C++11)\fP      specifies that the storage for the variable should be
                                 aligned by specific amount
   aligned_storage               defines the type suitable for use as uninitialized
   \fI(C++11)\fP(deprecated in C++23)  storage for types of given size
                                 \fI(class template)\fP
   align                         aligns a pointer in a buffer
   \fI(C++11)\fP                       \fI(function)\fP
                                 specifies that the expression will always evaluate to
   [[assume(expression)]](C++23) true at a given point
                                 (attribute specifier)

.SH Category:
     * Todo no example
